package com.bitoon.basketdudes.web.estadisticas;

import com.bitoon.basketdudes.web.BaseAction;
import com.bitoon.basketdudes.web.admin.*;
import com.bitoon.basketdudes.web.admin.Pais;
import com.bitoon.basketdudes.web.datos.InfoCabeceraXHR;
import com.bitoon.basketdudes.web.jpa.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import javax.persistence.*;
import org.apache.log4j.Logger;

public class InfoGlobal extends BaseAction {
    
    private InfoCabeceraXHR cabecera;
    private int pagina = 1;
    private int cuantos;
    private List<DatoCadenaNumeros> datos;

    private int usuariosActivosTotales;
    private int equiposCreadosTotales;
    private int usuariosNoActivados;
    private int usuariosConEquipo;
    private String nick;
    private Usuario manager;

    private String fechas;
    private String fechaInicio;
    private String fechaFin;

    private String tipo;
    private String fechaResumenInicio;
    private String fechaResumenFin;
    private String familia;
    //checkbox's
    private String equipos;
    private String partidos;
    private String usuarios;
    
    private List<DatoFechaNumero> usuariosRegistrados;
    private List<DatoFechaNumero> usuariosRegistradosInverso;
    private List<DatoFechaNumero> equiposPorDia;
    private List<DatoFechaNumero> equiposPorDiaInverso;
    private List<DatoFechaNumero> partidosPorDia;
    private List<DatoFechaNumero> partidosPorDiaInverso;
    private List<DatoCadenaNumero> equiposPorPartidosJugados;
    private List<DatoCadenaNumero> managersPorPartidosJugados;
    private List<DatoCadenaNumero> managersPorGenero;
    private List<DatoCadenaNumero> managersPorPais;
    private List<DatoCadenaNumero> managersXdiasSinJugar;
    private List<DatoCadenaNumero> equiposPorNivel;
    private List<DatoCadenaNumero> nivelSemana;
    private List<PartidoEnJuego> partidoJuego;
    private List<PartidoParaComentar> partidoComentar;
    private List<DatoFechaNumeros> listaResumen;
    private List<DatoFechaNumeros> listaResumenInversa;
    private List<DatoCadenaNumero> managersPorEdad;
    private List<DatoCadenaNumero> managersActividad;
    private List<DatoCadenaNumero> managersActividadInversa;

    /*campos estadistica comparar usuarios/paises*/
    private String pais1;
    private String pais2;
    private String pais3;
    private String pais4;
    private String pais5;
    private String nombre_pais1;
    private String nombre_pais2;
    private String nombre_pais3;
    private String nombre_pais4;
    private String nombre_pais5;
    private List<Pais> desplegablePaises;

    /* campos estadistica objetos mas comprados*/
    private List<DatoCadenaNumeros> listaRopa;
    private List<DatoCadenaNumeros> listaSobres;
    private List<DatoCadenaNumeros> listaJugadores;
    private List<DatoCadenaNumeros> listaCartas;
    private InfoCabeceraXHR cabecera_cartas;
    private InfoCabeceraXHR cabecera_jugadores;
    private InfoCabeceraXHR cabecera_ropa;

    //checkbox's resumen tienda
    private String totales;
    private String bitoones;
    private String duddies;
    private List<DatoFechaNumero> listaAux;
    private List<DatoFechaNumero> listaAuxInversa;
    private List<DatoFechaNumero> comprasTotales;
    private List<DatoFechaNumero> comprasTotalesInverso;
    private List<DatoFechaNumero> comprasConBitoones;
    private List<DatoFechaNumero> comprasConBitoonesInverso;
    private List<DatoFechaNumero> comprasConDuddies;
    private List<DatoFechaNumero> comprasConDuddiesInverso;

    private int actividad;

    private List<List<DatoFechaNumero>> matriz_managersPorPais; //para los gráficos
    private List<List<String>> listaPaises; //para los nombres de los paises

    private Logger log = Logger.getLogger(InfoGlobal.class);

    //acceso a la clase estatica BaseActionAdmin
    private BaseActionAdmin bsaadmin = BaseActionAdmin.getInstance();

    public String getSesionFecha() {
        return (String)session.get("est_fechas");
    }
    public Date getSesionFechaIni(){
        return (Date)session.get("est_finicio");
    }

    public Date getSesionFechaFin(){
        return (Date)session.get("est_ffin");
    }

    @Override
    public String execute() {

        return SUCCESS;
    }

    public String generales() {

        //Equipos Creados
        setEquiposCreadosTotales(NumeroTotal("select count(*) as cuantos from basket.equipo"));
        //Usuarios Activos
        setUsuariosActivosTotales(NumeroTotal("select count(*) as cuantos from central.usuario where status = 1"))  ;

        //Usuarios NO Activos
        setUsuariosNoActivados(NumeroTotal("select count(*) as numero from central.usuario where status <> 1 and f_alta < date_trunc('day',now())"));
        //Usuarios con Equipo
        setUsuariosConEquipo(NumeroTotal("select count(distinct(usuario_id))as numero from basket.equipo where f_alta < date_trunc('day',now())"));

        return SUCCESS;
    } 
    
    public String registrados(){
        try{
            log.debug("[registrados] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo==null) || 
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                log.debug("[estadisticas] registrados normal");
                setUsuariosRegistrados(dameFechaNumero("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario group by fecha order by fecha desc"));
                setUsuariosRegistradosInverso(dameFechaNumero("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario group by fecha order by fecha asc"));
            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[estadisticas] registrados semana/mes");
                }else{
                    log.debug("[estadisticas] registrados por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                setUsuariosRegistrados(dameFechaNumero("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "' group by fecha order by fecha desc"));
                setUsuariosRegistradosInverso(dameFechaNumero("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "' group by fecha order by fecha asc"));
            }
        } catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }

    private Date dameFechaMenosDias(int dias){
        /* Resta una cantidad de dias a la fecha actual y devuelve el resultado */
        GregorianCalendar calendario = new GregorianCalendar();
        calendario.add(Calendar.DATE, -dias);
        return calendario.getTime();
    }

    private Date dameFecha(String dia){
        /* Resta una cantidad de dias a la fecha actual y devuelve el resultado */
        SimpleDateFormat formatoDelTexto = new SimpleDateFormat("dd/MM/yyyy");
        Date fecha = null;
        try {
            fecha = formatoDelTexto.parse(dia);
        } catch (Exception ex) {}
        return fecha;
    }

    public String activarFechas(){

        session.put("est_fechas", fechas);
        session.put("est_finicio",fechaInicio);
        session.put("est_ffin",fechaFin);

        return SUCCESS;
    }

    public void DesactivarFechas(){
        session.put("est_fechas", null);
        session.put("est_finicio",null);
        session.put("est_ffin",null);
        session.put("tipoFiltro",null);
    }

    public void activarInputs(){
        /* variables para compartir en acciones JS */
        session.put("equipos", equipos);
        session.put("partidos",partidos);
        session.put("usuarios",usuarios);
    }


    public void DesactivarInputs(){
        /* variables para compartir en acciones JS */
        session.put("equipos", null);
        session.put("partidos",null);
        session.put("usuarios",null);
    }

    public String resumenDiario(){
        DesactivarFechas();
        
        //rescatamos las fechas si se han pasado
        if(fechaResumenInicio!=null && fechaResumenFin!=null
           && fechaResumenInicio.compareTo("")!=0 && fechaResumenFin.compareTo("")!=0){
            fechaInicio = fechaResumenInicio;
            fechaFin = fechaResumenFin;
        }

        //usuarios registrados
        registrados();
        //partidos dia
        PporDia();
        //equipos dia
        EporDia();

        //fusionar las tres listas en un array de 4 columnas por fila
        // dia / equipos / partidos / managers
        ArrayList<DatoFechaNumeros> listaR = new ArrayList<DatoFechaNumeros>();

        log.debug("[resumenDiario] tipo:" + equipos + "," + partidos + "," + usuarios);
        activarInputs();

        if(equipos==null && partidos==null && usuarios==null){
            //primera vez que entro en la estadística
            inicializarResumen(listaR,equiposPorDiaInverso,1);
            insertarFechaListaResumen(partidosPorDiaInverso,listaR,2);
            insertarFechaListaResumen(usuariosRegistradosInverso,listaR,3);
        }else{
            //si no se entra por primera vez
            if(equipos!=null && equipos.compareTo("on")==0){
                log.debug("[resumenDiario] equipos entro:" + equiposPorDiaInverso.size());
                inicializarResumen(listaR,equiposPorDiaInverso,1);
            }

            if(equipos!=null && equipos.compareTo("on")==0 
               &&  partidos!=null && partidos.compareTo("on")==0){
                log.debug("[resumenDiario] partidos todos");
                insertarFechaListaResumen(partidosPorDiaInverso,listaR,2);
            }else{
                if(partidos!=null && partidos.compareTo("on")==0){
                    log.debug("[resumenDiario] partidos inicializo");
                    inicializarResumen(listaR,partidosPorDiaInverso,2);
                }
            }

            if(equipos!=null && partidos!=null && usuarios!=null && equipos.compareTo("on")==0
               && partidos.compareTo("on")==0 && usuarios.compareTo("on")==0){
                log.debug("[resumenDiario] usuarios todos");
                insertarFechaListaResumen(usuariosRegistradosInverso,listaR,3);
            }else{
                //combinaciones con equipos o partidos,sino inicializar
                if(equipos!=null  && usuarios!=null && equipos.compareTo("on")==0 && usuarios.compareTo("on")==0){
                      log.debug("[resumenDiario] usuarios todos 1");
                      insertarFechaListaResumen(usuariosRegistradosInverso,listaR,3);
                }else{
                    if(partidos!=null  && usuarios!=null && partidos.compareTo("on")==0 && usuarios.compareTo("on")==0){
                        log.debug("[resumenDiario] usuarios todos 2");
                        insertarFechaListaResumen(usuariosRegistradosInverso,listaR,3);
                    }else{
                        if(usuarios!=null && usuarios.compareTo("on")==0){
                            log.debug("[resumenDiario] usuarios entro");
                            inicializarResumen(listaR,usuariosRegistradosInverso,3);
                        }
                    }
                } 
            }
        }
        
        setListaResumen(listaR);
        //invertir la lista y asignarla
        listaResumenInversa = new ArrayList<DatoFechaNumeros>();
        for(int i=listaResumen.size()-1;i>=0;--i){
            listaResumenInversa.add(listaResumen.get(i));
        }

        return SUCCESS;
    }

    public void inicializarResumen(ArrayList<DatoFechaNumeros> listaR,List<DatoFechaNumero> Lista,int pos){
        try{
            DatoFechaNumeros dfns;

            for(DatoFechaNumero d: Lista){
                dfns = new DatoFechaNumeros();
                dfns.setFecha(d.getFecha());
                if(pos==1){
                    dfns.setPos1(d.getNumero());
                }else{
                    dfns.setPos1(0);
                }
                if(pos==2){
                    dfns.setPos2(d.getNumero());
                }else{
                    dfns.setPos2(0);
                }
                if(pos==3){
                    dfns.setPos3(d.getNumero());
                }else{
                    dfns.setPos4(0);
                }
                if(pos==4){
                    dfns.setPos2(d.getNumero());
                }else{
                    dfns.setPos4(0);
                }
                if(pos==5){
                    dfns.setPos5(d.getNumero());
                }else{
                    dfns.setPos5(0);
                }
                listaR.add(dfns);
            }
        }catch (Exception e) {
            log.error("[inicializarResumen] Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
    }
    
    public void insertarFechaListaResumen(List<DatoFechaNumero> Lista,ArrayList<DatoFechaNumeros> listaResumen,int posicionDato){
        try{            
            boolean sw;
            int pos;
            int i;
            for(DatoFechaNumero d: Lista){
                sw=false;
                pos=-1;
                i=0;
                DatoFechaNumeros dfnum2 = null;
                //log.debug("[insertarFechaListaResumen] fecha d: "+d.getFecha());
                while(i<listaResumen.size()-1 && sw==false){

                    dfnum2 = listaResumen.get(i);
                    //si es el primero
                    if(i==0 && (d.getFecha().compareTo(dfnum2.getFecha()) < 0) ){
                        //log.debug("[insertarFechaListaResumen] primero");
                        pos = 0;
                        sw=true;
                    }
                    //si es el ultimo
                    if(d.getFecha().compareTo(listaResumen.get(listaResumen.size()-1).getFecha())>0 && sw==false){
                        //log.debug("[insertarFechaListaResumen] ultimo");
                        pos = listaResumen.size();
                        sw=true;
                    } else { //si es intermedio
                        //si es igual
                        //log.debug("[insertarFechaListaResumen] intermedio: " + posicionDato);
                        if(dfnum2.getFecha().compareTo(d.getFecha())==0){
                            if(posicionDato==1){ 
                                listaResumen.get(i).setPos1(d.getNumero());
                            }
                            if(posicionDato==2){ 
                                listaResumen.get(i).setPos2(d.getNumero());
                            }
                            if(posicionDato==3){ 
                                listaResumen.get(i).setPos3(d.getNumero());
                            }
                            if(posicionDato==4){ 
                                listaResumen.get(i).setPos4(d.getNumero());
                            }
                            if(posicionDato==5){
                                listaResumen.get(i).setPos5(d.getNumero());
                            }
                            sw=true;
                        }else{
                            //si es mayor que la fecha actual y es menor a la siguiente,es su posicion
                            if(dfnum2.getFecha().compareTo(d.getFecha()) < 0
                               && listaResumen.get(i+1).getFecha().compareTo(d.getFecha())> 0){
                                pos = i+1;
                                sw=true;
                            }
                        }//fin si igual
                    }//fin si es el ultimo
                    ++i;
                }//fin while

                DatoFechaNumeros dato = new DatoFechaNumeros();
                dato.setFecha(d.getFecha());
                if(posicionDato==1){
                    dato.setPos1(d.getNumero());
                }else{
                    dato.setPos1(0);
                }
                if(posicionDato==2){
                    dato.setPos2(d.getNumero());
                }else{
                    dato.setPos2(0);
                }
                if(posicionDato==3){
                    dato.setPos3(d.getNumero());
                }else{
                    dato.setPos3(0);
                }
                if(posicionDato==4){
                    dato.setPos4(d.getNumero());
                }else{
                    dato.setPos4(0);
                }
                if(posicionDato==5){
                    dato.setPos5(d.getNumero());
                }else{
                    dato.setPos5(0);
                }

                if(pos>-1){
                    //si hay que insertarlo en una posicion x de la lista resumen
                    if(pos!=listaResumen.size()){
                        listaResumen.add(pos, dato);    
                    }else{ //si es el ultimo
                        listaResumen.add(dato);
                    }
                }
            }
        }catch (Exception e) {
            log.error("[insertarFechaListaResumen] Error", e.fillInStackTrace());
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
    }
    
    public String EporDia(){
        //Equipos creados por dia
        try{            
            log.debug("[EporDia] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                log.debug("[estadisticas] EporDia normal");
                setEquiposPorDia(dameEquiposPorDia("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from basket.equipo group by fecha order by fecha desc"));
                setEquiposPorDiaInverso(dameEquiposPorDia("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from basket.equipo group by fecha order by fecha asc"));
            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[estadisticas] EporDia semana/mes");
                }else{
                    log.debug("[estadisticas] EporDia por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                setEquiposPorDia(dameEquiposPorDia("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from basket.equipo where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "'group by fecha order by fecha desc"));
                setEquiposPorDiaInverso(dameEquiposPorDia("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from basket.equipo where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "'group by fecha order by fecha asc"));

            }
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }
    
    public String PporDia(){
        //Partidos por dia
        try{
            log.debug("[PporDia] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                log.debug("[estadisticas] ppdia normal");
                setPartidosPorDia(damePartidosPorDia("select date_trunc('day',f_partido) as fecha, count(*) as numero,0 as porcentaje from basket.partido group by fecha order by fecha desc"));
                setPartidosPorDiaInverso(damePartidosPorDia("select date_trunc('day',f_partido) as fecha, count(*) as numero,0 as porcentaje from basket.partido group by fecha order by fecha asc"));

            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[estadisticas] ppdia semana/mes");
                }else{
                    log.debug("[estadisticas] ppdia por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                setPartidosPorDia(damePartidosPorDia("select date_trunc('day',f_partido) as fecha, count(*) as numero,0 as porcentaje  from basket.partido where f_partido >= '" + fInicio + "' and f_partido <= '" + fFin + "' group by fecha order by fecha desc"));
                setPartidosPorDiaInverso(damePartidosPorDia("select date_trunc('day',f_partido) as fecha, count(*) as numero,0 as porcentaje from basket.partido where f_partido >= '" + fInicio + "' and f_partido <= '" + fFin + "' group by fecha order by fecha asc"));
            }
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }
    
    public String EporPartidos(){
        try{
            log.debug("[EporPartidos] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                //Equipos Segun los partidos jugados
                setEquiposPorPartidosJugados(dameEquiposPorPartidosJugados("select count(*) from basket.est_equipo ee, basket.equipo e where ee.equipo_id = e.id and e.f_alta < date_trunc('day',now())"));
            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[EporPartidos] registrados semana/mes");
                }else{
                    log.debug("[EporPartidos] registrados por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                setEquiposPorPartidosJugados(dameEquiposPorPartidosJugados("select count(*) from basket.est_equipo ee, basket.equipo e where ee.equipo_id = e.id and e.f_alta >= '" + fInicio + "' and e.f_alta <= '" + fFin + "'"));
            }
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }
    
    public String MporPartidos(){
        try{
            //Managers segun los partidos jugados
            log.debug("[MporPartidos] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                //Equipos Segun los partidos jugados
                setManagersPorPartidosJugados(dameManagersPorPartidosJugados("select count(*) from (select e.usuario_id, sum(partidos) as total from basket.est_equipo ee, basket.equipo e where ee.equipo_id = e.id and e.f_alta < date_trunc('day',now()) group by e.usuario_id) s"));
            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[MporPartidos] registrados semana/mes");
                }else{
                    log.debug("[MporPartidos] registrados por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                setManagersPorPartidosJugados(dameManagersPorPartidosJugados("select count(*) from (select e.usuario_id, sum(partidos) as total from basket.est_equipo ee, basket.equipo e where ee.equipo_id = e.id and e.f_alta >= '" + fInicio + "' and e.f_alta <= '" + fFin + "' group by e.usuario_id) s"));
            }
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }

    public String MporGenero(){
        try{
            //Managers por genero
            log.debug("Entro");
            setManagersPorGenero((dameManagersPorGenero()));
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }

    public String MporPais(){
        try{
            //Managers por pais
            setManagersPorPais(dameManagersPorPais());
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }

    public String XdiasSinJugar(){
        try{
            setManagersXdiasSinJugar(dameXdiasSinJugar());
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }


    public String consultarManager() {
        log.info("Entrando en consultarManager ...");
        try{
            if(nick!=null){

            setManager(consultaManager(nick));
            }

        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }

    public String equiposPorNivel(){
        try{
            setEquiposPorNivel(dameEquiposPorNivel());
        }catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }

        return SUCCESS;
    }

    public String nivelSemana(){
        try{
            log.debug("[nivelSemana] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                Date fInicio = null;
                fInicio = dameFechaMenosDias(7);
                setNivelSemana(dameNivelSemana("select e.nivel as cadena, count(*) as numero,0 as porcentaje from basket.equipo e, basket.partido p where (e.id = p.equipo_id1 or e.id = p.equipo_id2) and p.f_partido >= '"+fInicio+"' group by nivel order by nivel "));
            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[nivelSemana] registrados semana/mes");
                }else{
                    log.debug("[nivelSemana] registrados por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                setNivelSemana(dameNivelSemana("select e.nivel as cadena, count(*) as numero,0 as porcentaje from basket.equipo e, basket.partido p where (e.id = p.equipo_id1 or e.id = p.equipo_id2) and p.f_partido >= '" + fInicio + "' and e.f_alta <= '" + fFin + "' group by nivel order by nivel "));
            }
        }catch(Exception e){
            log.error("Error",e);
        }finally{
            try {/*em.close();*/ } catch (Exception e) { }
        }

        return SUCCESS;

    }

    public String partidoEnJuego(){
         try{

             setPartidoComentar(damePartidoEnJuego());

        }catch(Exception e){
            log.error("Error",e);
        }finally{
            try {/*em.close();*/ } catch (Exception e) { }
        }

        return SUCCESS;
    }

    //Funcion para el numero total de usuarios activos
    private int NumeroTotal (String sql){
        int numero = 0;
        EntityManager em = bsaadmin.getEmfAdmin().createEntityManager();
        try{
            Query q = em.createNativeQuery(sql);
           // int usuariosActivosTotales;
            numero = ((BigInteger)q.getSingleResult()).intValue();

        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        log.debug("Numero vale" + numero);
        return numero;
    }

    //Funcion peticiones de codigo

    private List<DatoFechaNumero> dameFechaNumero(String sql) {
        List<DatoFechaNumero> retorno = new ArrayList<DatoFechaNumero>();
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
        try {
            Query q = em.createNativeQuery(sql, DatoFechaNumero.class);
            //peticionesCodigo = new ArrayList<DatoFechaNumero>();
            retorno = (List<DatoFechaNumero>)q.getResultList();
        } catch (Exception e) {
                log.error("[dameFechaNumero] Error ", e);
        } finally {
                try { em.close(); } catch (Exception e) { }
        }
     
    return retorno;
    }
  
    //Funcion equipos por dia
    private List<DatoFechaNumero> dameEquiposPorDia (String sql){
        List<DatoFechaNumero> retorno = new ArrayList<DatoFechaNumero>();
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();

        try {
            Query q = em.createNativeQuery(sql, DatoFechaNumero.class);
            //setEquiposPorDia(new ArrayList<DatoFechaNumero>());
            retorno = (List<DatoFechaNumero>)q.getResultList();
        } catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;

    }

    //Funcion Partidos jugados por dia
    private List<DatoFechaNumero> damePartidosPorDia (String sql){
        List<DatoFechaNumero> retorno = new ArrayList<DatoFechaNumero>();
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();

        try {
            Query q = em.createNativeQuery(sql, DatoFechaNumero.class);
            //setPartidosPorDia(new ArrayList<DatoFechaNumero>());
            retorno = (List<DatoFechaNumero>)q.getResultList();
        } catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;

    }

    //Equipos Segun partidos jugados
    private List<DatoCadenaNumero> dameEquiposPorPartidosJugados(String parteComun){
        List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
        DatoCadenaNumero aux;
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
       
       try {
           //compongo la select con una parte comun y partes variables(textos traducidos)
           String parteComunSQL = parteComun;
           String[][] variables = {
               {"and ee.partidos = 0", getText("estadisticas.partidos_jugados_equipos.dato_1")},
               {"and ee.partidos >= 1 and ee.partidos <= 10", getText("estadisticas.partidos_jugados_equipos.dato_2")},
               {"and ee.partidos >= 11 and ee.partidos <= 25", getText("estadisticas.partidos_jugados_equipos.dato_3")},
               {"and ee.partidos >= 26 and ee.partidos <= 50", getText("estadisticas.partidos_jugados_equipos.dato_4")},
               {"and ee.partidos >= 51 and ee.partidos <= 100", getText("estadisticas.partidos_jugados_equipos.dato_5")},
               {"and ee.partidos >= 101 and ee.partidos <= 250", getText("estadisticas.partidos_jugados_equipos.dato_6")},
               {"and ee.partidos > 250", getText("estadisticas.partidos_jugados_equipos.dato_7")}
           };

           retorno = new ArrayList<DatoCadenaNumero>();

           for(String[] linea : variables) {
               String parteVariableSQL = linea[0];
               String textoArbitrario = linea[1];

               Query q = em.createNativeQuery(parteComunSQL + " " + parteVariableSQL);
               aux = new DatoCadenaNumero();
               aux.setCadena(textoArbitrario);
               aux.setNumero(((BigInteger)q.getSingleResult()).intValue());
               retorno.add(aux);
           }

       } catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        
        return retorno;
    }

    //Managers por partidos Jugados
    private List<DatoCadenaNumero> dameManagersPorPartidosJugados(String parteComun){

        List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
        DatoCadenaNumero aux;
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();

        try{
           //compongo la select con una parte comun y partes variables(textos traducidos)
           String parteComunSQL = parteComun;
           String[][] variables = {
               {"where s.total = 0", getText("estadisticas.partidos_jugados_managers.dato_1")},
               {"where s.total >= 1 and s.total <= 10", getText("estadisticas.partidos_jugados_managers.dato_2")},
               {"where s.total >= 11 and s.total <= 25", getText("estadisticas.partidos_jugados_managers.dato_3")},
               {"where s.total >= 11 and s.total <= 25", getText("estadisticas.partidos_jugados_managers.dato_4")},
               {"where s.total >= 51 and s.total <= 100", getText("estadisticas.partidos_jugados_managers.dato_5")},
               {"where s.total >= 101 and s.total <= 250", getText("estadisticas.partidos_jugados_managers.dato_6")},
               {"where s.total > 250", getText("estadisticas.partidos_jugados_managers.dato_7")}
           };

            retorno = new ArrayList<DatoCadenaNumero>();

            for(String[] linea : variables) {
               String parteVariableSQL = linea[0];
               String textoArbitrario = linea[1];

               Query q = em.createNativeQuery(parteComunSQL + " " + parteVariableSQL);
               aux = new DatoCadenaNumero();
               aux.setCadena(textoArbitrario);
               aux.setNumero(((BigInteger)q.getSingleResult()).intValue());
               retorno.add(aux);
           }
        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

   private List<DatoCadenaNumero> dameManagersPorGenero(){
       List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
       //DatoCadenaNumero aux;
       EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
       try{
           Query q = em.createNativeQuery("select count(*) as numero from central.usuario");
           int total = ((BigInteger)q.getSingleResult()).intValue();
           q = em.createNativeQuery("select genero as cadena, count(*) as numero,CAST(CAST(100*count(*)AS FLOAT)/"+total+" AS decimal (18,1)) as porcentaje from central.usuario group by genero order by genero", DatoCadenaNumero.class);
           retorno = (List<DatoCadenaNumero>)q.getResultList();

       }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
       return retorno;
   }

   private List<DatoCadenaNumero> dameManagersPorPais(){
        List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
         EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
         try{

             Query q = em.createNativeQuery("select count(*) as numero from central.usuario u, central.pais p where u.pais_id = p.id");
             int total = ((BigInteger)q.getSingleResult()).intValue();
             q = em.createNativeQuery("select p.nombre as cadena, count(*) as numero,CAST(CAST(100*count(*)AS FLOAT)/"+total+" AS decimal (18,1)) as porcentaje  from central.usuario u, central.pais p where u.pais_id = p.id group by p.nombre order by numero desc", DatoCadenaNumero.class);
             setManagersPorPais(new ArrayList<DatoCadenaNumero>());
             retorno = (List<DatoCadenaNumero>)q.getResultList();
         }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
       return retorno;
   }

   private List<DatoCadenaNumero> dameXdiasSinJugar(){
       List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
       DatoCadenaNumero aux;
       EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();

       try{
           //compongo la select con una parte comun y partes variables(textos traducidos)
           String parteComunSQL = "select count(*) from (select u.id, max(p.f_partido) as ultima_fecha from basket.equipo e, basket.partido p, central.usuario u where (p.equipo_id1 = e.id or p.equipo_id2 = e.id) and u.id = e.usuario_id group by u.id order by ultima_fecha desc) s ";
           String[][] variables = {
               {"where s.ultima_fecha < date_trunc('day',now()) - interval '60 days'", getText("estadisticas.dias_sin_jugar_managers.dato_1")},
               {"where s.ultima_fecha >= date_trunc('day',now()) - interval '60 days' and s.ultima_fecha < date_trunc('day',now()) - interval '46 days'", getText("estadisticas.dias_sin_jugar_managers.dato_2")},
               {"where s.ultima_fecha >= date_trunc('day',now()) - interval '45 days' and s.ultima_fecha < date_trunc('day',now()) - interval '31 days'", getText("estadisticas.dias_sin_jugar_managers.dato_3")},
               {"where s.ultima_fecha >= date_trunc('day',now()) - interval '30 days' and s.ultima_fecha < date_trunc('day',now()) - interval '15 days'", getText("estadisticas.dias_sin_jugar_managers.dato_4")},
               {"where s.ultima_fecha >= date_trunc('day',now()) - interval '14 days' and s.ultima_fecha < date_trunc('day',now()) - interval '8 days'",  getText("estadisticas.dias_sin_jugar_managers.dato_5")},
               {"where s.ultima_fecha >= date_trunc('day',now()) - interval '7 days' and s.ultima_fecha < date_trunc('day',now()) - interval '4 days'",   getText("estadisticas.dias_sin_jugar_managers.dato_6")},
               {"where s.ultima_fecha >= date_trunc('day',now()) - interval '3 days' and s.ultima_fecha < date_trunc('day',now())", getText("estadisticas.dias_sin_jugar_managers.dato_7")}
           };

            retorno = new ArrayList<DatoCadenaNumero>();

            for(String[] linea : variables) {
               String parteVariableSQL = linea[0];
               String textoArbitrario = linea[1];

               Query q = em.createNativeQuery(parteComunSQL + " " + parteVariableSQL);
               aux = new DatoCadenaNumero();
               aux.setCadena(textoArbitrario);
               aux.setNumero(((BigInteger)q.getSingleResult()).intValue());
               retorno.add(aux);
           }
        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
   }

   //prueba funcion comun
   private List<DatoCadenaNumero> dameDatos(String sql,String variables[][]){

        List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
        DatoCadenaNumero aux;
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
        try{
            String parteComunSQL = sql;

            retorno = new ArrayList<DatoCadenaNumero>();

            for(String[] linea : variables) {
               String parteVariableSQL = linea[0];
               String textoArbitrario = linea[1];

               Query q = em.createNativeQuery(parteComunSQL + " " + parteVariableSQL);
               aux = new DatoCadenaNumero();
               aux.setCadena(textoArbitrario);
               aux.setNumero(((BigInteger)q.getSingleResult()).intValue());
               retorno.add(aux);
           }
        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        return retorno;
    }

    //consultar el manager
    private Usuario consultaManager(String nick) {
        EntityManager em = null;
     
        try {
            em = getBsaadmin().getEmfAdmin().createEntityManager(); // checked

            Query q = em.createNamedQuery("Usuario.findByNick");
            q.setParameter("nick", nick.toLowerCase());

            manager = (Usuario)q.getSingleResult();

        } catch (NoResultException e) {
           log.info("[getManager][usuario " + nick + " no encontrado]");
        } catch (Exception e) {
            log.error("[getManager]: " + e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return manager;
    }

    //Equipos Segun Nivel
    private List<DatoCadenaNumero> dameEquiposPorNivel(){
        List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();

        try{
             Query q = em.createNativeQuery("select nivel as cadena, count(*) as numero,0 as porcentaje from basket.equipo e group by nivel order by nivel", DatoCadenaNumero.class);
             setEquiposPorNivel(new ArrayList<DatoCadenaNumero>());
             retorno = (List<DatoCadenaNumero>)q.getResultList();

        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    //Partidos segun los niveles de los equipos
    private List<DatoCadenaNumero> dameNivelSemana(String consulta){
        List<DatoCadenaNumero> retorno = new ArrayList<DatoCadenaNumero>();
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
        try{
            Query q = em.createNativeQuery(consulta, DatoCadenaNumero.class);
            setNivelSemana(new ArrayList<DatoCadenaNumero>());
            retorno = (List<DatoCadenaNumero>)q.getResultList();
        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        return retorno;
    }

    private List<PartidoParaComentar> damePartidoEnJuego(){
        List<PartidoEnJuego> retorno = new ArrayList<PartidoEnJuego>();
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
        List<PartidoParaComentar> listaComentar = new ArrayList<PartidoParaComentar>();

        try {

            // Primero, leemos de la base de datos en una lista de PartidoEnJuego
             Query q = em.createNativeQuery("select p.id as id_cp, p.cuarto_juego as cuartoJuego, p.puntos_equipo1 as puntos_equipo1, p.puntos_equipo2 as puntos_equipo2, p.f_alta as f_alta, e.nivel as nivel, e.id as id_be, r.posicion as posicion from catalogo.partidos p, basket.equipo e, rankings.ranking r where p.f_alta >= '20110531' and (p.equipo1_id = e.id or p.equipo2_id = e.id) and r.id = e.id order by p.f_alta desc", PartidoEnJuego.class);
             setPartidoJuego(new ArrayList<PartidoEnJuego>());
             retorno = (List<PartidoEnJuego>)q.getResultList();
             
             // "Pasar" la informacion de la lista de PartidoEnJuego a otra lista de PartidosParaComentar
             int i=0;
             PartidoParaComentar pnuevo = null;
             for (PartidoEnJuego p : partidoJuego) {
                 if(i%2==0){
                     pnuevo = new PartidoParaComentar();
                     
                     pnuevo.setCuarto(p.getCuartoJuego());
                     pnuevo.setIdPartido(p.getId_cp());
                     pnuevo.setPos1(p.getPosicion());
                     pnuevo.setPtos1(p.getPuntos_equipo1());
                     
                     Equipo e1 = new Equipo();
                     e1.setId(p.getId_be());                     
                     pnuevo.setEquipo1(e1);
                     
                 } else {
                     
                     pnuevo.setPos2(p.getPosicion());
                     pnuevo.setPtos2(p.getPuntos_equipo2());

                     Equipo e2= new Equipo();
                     e2.setId(p.getId_be());
                     pnuevo.setEquipo2(e2);

                     listaComentar.add(pnuevo);
                 }
             }

        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        return listaComentar;
    }

    public String compararUsuariosPais(){
        try{
            log.debug("nombre_pais1: " + nombre_pais1);
            log.debug("pais1: " + pais1);
            matriz_managersPorPais = new ArrayList<List<DatoFechaNumero>>();
            listaPaises = new ArrayList<List<String>>();
            if(pais1!=null && pais1.compareTo("0")!=0){
                matriz_managersPorPais.add(registradosPorPais(pais1,"asc"));  //gráfico
                ArrayList<String> m = new ArrayList<String>();
                m.add(pais1.toLowerCase());
                m.add(nombre_pais1);
                listaPaises.add(m);
            }
            if(pais2!=null && pais2.compareTo("0")!=0){
                matriz_managersPorPais.add(registradosPorPais(pais2,"asc"));  //gráfico
                ArrayList<String> m = new ArrayList<String>();
                m.add(pais2.toLowerCase());
                m.add(nombre_pais2);
                listaPaises.add(m);
            }
            if(pais3!=null && pais3.compareTo("0")!=0){
                matriz_managersPorPais.add(registradosPorPais(pais3,"asc"));  //gráfico
                ArrayList<String> m = new ArrayList<String>();
                m.add(pais3.toLowerCase());
                m.add(nombre_pais3);
                listaPaises.add(m);
            }
            if(pais4!=null && pais4.compareTo("0")!=0){
                matriz_managersPorPais.add(registradosPorPais(pais4,"asc"));  //gráfico
                ArrayList<String> m = new ArrayList<String>();
                m.add(pais4.toLowerCase());
                m.add(nombre_pais4);
                listaPaises.add(m);
            }
            if(pais5!=null && pais5.compareTo("0")!=0){
                matriz_managersPorPais.add(registradosPorPais(pais5,"asc"));  //gráfico
                ArrayList<String> m = new ArrayList<String>();
                m.add(pais5.toLowerCase());
                m.add(nombre_pais5);
                listaPaises.add(m);
            }
            log.debug("[compararUsuariosPais] session: "+session.get("pais1"));
            if(session.get("pais1")==null){
                log.debug("[compararUsuariosPais] entro a crear la lista");
                //si no vengo de una accion JS
                //creo la lista mezclada de fechas y paises
                // Fecha / pais1 / pais2 / pais3 / pais4 / pais5
                ArrayList<DatoFechaNumeros> listaR = new ArrayList<DatoFechaNumeros>();
                int i;
                for(i=0;i<matriz_managersPorPais.size();++i){
                    if(i==0){
                        log.debug("[compararUsuariosPais] inicializo paises");
                        inicializarResumen(listaR,matriz_managersPorPais.get(i),1);
                    }else{
                        log.debug("[compararUsuariosPais] inserto pais");
                        insertarFechaListaResumen(matriz_managersPorPais.get(i),listaR,(i+1));
                    }
                }
                setListaResumen(listaR);
                //falta invertir la lista
                listaResumenInversa = new ArrayList<DatoFechaNumeros>();
                log.debug("[listaR] size: "+listaR.size());
                for(int j=listaR.size()-1;j>=0;--j){
                    listaResumenInversa.add(listaR.get(j));
                }
                log.debug("[listaInversa] size: "+listaResumenInversa.size());
            }
            activarPaises();

            //creo la lista de paises para los desplegables
            log.debug("CREO EL DESPLEGABLE");
            LectorFicheroPaises l = new LectorFicheroPaises();
            l.leerFicheroPaises();
            desplegablePaises = l.getListaPaises();
            
        }catch(Exception e){
            log.error("[compararUsuariosPais] Error: "+e);
        }finally{
            try {/*em.close();*/ } catch (Exception e) { }
        }
        return SUCCESS;
    }

    public String objetosMasCompradosXHR(){

        log.debug("[objetosMasCompradosXHR] familia: " + familia + ", tipo: " + tipo);

        String retorno = objetosMasComprados();

        return retorno;
    }

    public String objetosMasComprados(){

        Date fInicio = null;
        Date fFin = null;

        log.debug("[objetosMasComprados] fechaInicio: "+fechaInicio +"- fechaFin: "+ fechaFin +"- tipo: "+ tipo);

        //si son las tres null, o son las fechas null y el tipo distinto de vacio o '0'
        if(fechaInicio == null && fechaFin == null && tipo!=null
            || (fechaInicio != null && fechaFin != null && fechaInicio.compareTo("")==0
            && fechaFin.compareTo("")==0 && tipo!=null && tipo.compareTo("0")!=0 && tipo.compareTo("")!=0)){

            if(tipo!=null && tipo.compareTo("semana")==0){
                //Restamos la cantidad en la unidad conveniente,una semana
                fInicio = dameFechaMenosDias(7);
            }else{
                //Restamos la cantidad en la unidad conveniente,un mes
                fInicio = dameFechaMenosDias(30);
            }
            fFin =  new Date();
            log.debug("[objetosMasComprados] registrados semana/mes");
        }else{
            if(fechaInicio != null && fechaFin != null
               && fechaInicio.compareTo("")!=0 && fechaFin.compareTo("")!=0){
                log.debug("[objetosMasComprados] registrados por fechas");
                fInicio = dameFecha(fechaInicio);
                fFin = dameFecha(fechaFin);
            }
        }

        String fecha = "";
        if(fInicio!=null && fFin!=null){
            fecha = "and mc.f_alta >= '" + fInicio + "' and mc.f_alta <= '" + fFin + "'";
        }

        /*NOTA: USO EL PARAMETRO row_number() por cada fila porque Java si encuentra dos registros con el mismo
         nombre, a los repetidos les mete la información del primer registro, xeso hace falta distinguirlos por un campo id*/
        String select_carta = "select row_number() over(order by m.nombre) as id,m.nombre as cadena,c.categoria_id-510 as numero1,"
                              +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.carta cc on(mc.item_id = cc.id) where mc.item_id=c.id "+fecha+" group by mc.item_id),0) as numero2,"
                              +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.carta cc on(mc.item_id = cc.id and mc.puntos>0) where mc.item_id=c.id "+fecha+" group by mc.item_id),0) as numero3,"
                              +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.carta cc on(mc.item_id = cc.id and mc.valor>0) where mc.item_id=c.id "+fecha+" group by mc.item_id),0) as numero4 "
                              +"from basket.carta c join basket.m_carta m on(c.m_carta_id = m.id)"
                              +" order by numero2 desc";
        String select_jugador = "select row_number() over(order by maj.nombre) as id,maj.nombre as cadena,1 as numero1,"+
                                "COALESCE((select count(*)"+
                                " from central.movimiento mc join basket.jugador jj on(mc.item_id = jj.id) "+
                                " join basket.m_jugador mj on(mj.id=jj.m_jugador_id) where mj.nombre=maj.nombre"+
                                " "+fecha+" group by nombre),0) as numero2,"+
                                "COALESCE((select count(*)"+
                                " from central.movimiento mc join basket.jugador jj on(mc.item_id = jj.id) "+
                                " join basket.m_jugador mj on(mj.id=jj.m_jugador_id and mc.puntos>0) where mj.nombre=maj.nombre"+
                                " "+fecha+" group by nombre),0) as numero3,"+
                                "COALESCE((select count(*)"+
                                " from central.movimiento mc join basket.jugador jj on(mc.item_id = jj.id) "+
                                " join basket.m_jugador mj on(mj.id=jj.m_jugador_id and mc.valor>0) where mj.nombre=maj.nombre"+
                                " "+fecha+" group by nombre),0) as numero4 "+
                                " from basket.m_jugador maj join basket.jugador j on(j.m_jugador_id=maj.id)"+
                                " group by maj.nombre"+
                                " order by numero2 desc,maj.nombre asc";
        String select_ropa="select row_number() over(order by r.nombre) as id,r.nombre as cadena,r.categoria_id-2000 as numero1,"
                            +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.ropa rr on(mc.item_id = rr.id) where mc.item_id=r.id "+fecha+" group by mc.item_id),0) as numero2,"
                            +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.ropa rr on(mc.item_id = rr.id and mc.puntos>0) where mc.item_id=r.id "+fecha+" group by mc.item_id),0) as numero3,"
                            +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.ropa rr on(mc.item_id = rr.id and mc.valor>0) where mc.item_id=r.id "+fecha+" group by mc.item_id),0) as numero4"
                            +" from basket.ropa r"
                            +" order by numero2 desc";
        String select_sobre = "select row_number() over(order by s.nombre) as id,s.nombre as cadena,s.categoria_id-5500 as numero1,"
                            +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.sobre so on(mc.item_id = so.id) where mc.item_id=s.id "+fecha+" group by mc.item_id),0) as numero2,"
                            +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.sobre so on(mc.item_id = so.id and mc.puntos>0) where mc.item_id=s.id "+fecha+" group by mc.item_id),0) as numero3,"
                            +"COALESCE((select SUM(mc.item_uds) as unidades_vendidas from central.movimiento mc join basket.sobre so on(mc.item_id = so.id and mc.valor>0) where mc.item_id=s.id "+fecha+" group by mc.item_id),0) as numero4"
                            +" from basket.sobre s"
                            +" order by numero2 desc";

        if(cuantos==0){
            cuantos = BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_ELEMENTOS_POR_PAGINA;
        }

        if(familia==null || (familia.compareTo("")==0 && tipo.compareTo("")==0) || (familia!=null && familia.compareTo("carta")==0)){
            //cargo las cartas
            log.debug("[objetosMasComprados] cartas");
            listaCartas = objetosMasCompradosPaginado(cuantos,select_carta);
            setCabecera_cartas(new InfoCabeceraXHR());
            getCabecera_cartas().setCorrecto(1);
            getCabecera_cartas().setActual(getCabecera().getActual());
            getCabecera_cartas().setTotal(getCabecera().getTotal());
            getCabecera_cartas().setPrimeraPagina(getCabecera().getPrimeraPagina());
            getCabecera_cartas().setUltimaPagina(getCabecera().getUltimaPagina());
            getCabecera_cartas().setTotalRegistros(getCabecera().getTotalRegistros());
        }
        if(familia==null || (familia.compareTo("")==0 && tipo.compareTo("")==0) || (familia!=null && familia.compareTo("m_jugador")==0)){
            //jugadores
            log.debug("[objetosMasComprados] jugadores");
            listaJugadores = objetosMasCompradosPaginado(cuantos,select_jugador);
            setCabecera_jugadores(new InfoCabeceraXHR());
            getCabecera_jugadores().setCorrecto(1);
            getCabecera_jugadores().setActual(getCabecera().getActual());
            getCabecera_jugadores().setTotal(getCabecera().getTotal());
            getCabecera_jugadores().setPrimeraPagina(getCabecera().getPrimeraPagina());
            getCabecera_jugadores().setUltimaPagina(getCabecera().getUltimaPagina());
            getCabecera_jugadores().setTotalRegistros(getCabecera().getTotalRegistros());
        }
        if(familia==null || (familia.compareTo("")==0 && tipo.compareTo("")==0) || (familia!=null && familia.compareTo("ropa")==0)){
            //la ropa
            log.debug("[objetosMasComprados] ropa");
            listaRopa = objetosMasCompradosPaginado(cuantos,select_ropa);
            setCabecera_ropa(new InfoCabeceraXHR());
            getCabecera_ropa().setCorrecto(1);
            getCabecera_ropa().setActual(getCabecera().getActual());
            getCabecera_ropa().setTotal(getCabecera().getTotal());
            getCabecera_ropa().setPrimeraPagina(getCabecera().getPrimeraPagina());
            getCabecera_ropa().setUltimaPagina(getCabecera().getUltimaPagina());
            getCabecera_ropa().setTotalRegistros(getCabecera().getTotalRegistros());
        }
        if(familia==null || (familia.compareTo("")==0 && tipo.compareTo("")==0) || (familia!=null && familia.compareTo("sobre")==0)){
            //sobre
            log.debug("[objetosMasComprados] sobre");
            listaSobres = objetosMasCompradosPaginado(cuantos,select_sobre);
        }

        return SUCCESS;
    }

    public List<DatoCadenaNumeros> objetosMasCompradosPaginado(int elementos,String select){
        EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();
        List<DatoCadenaNumeros> lista = null;
        try{
            log.debug("[objetosMasCompradosPaginado] fechas: " + fechaInicio +", "+fechaFin+" ,tipo:" + tipo);

            Query q = em.createNativeQuery(select);

            int totalRegistros = q.getResultList().size();
            int totalPaginas = (totalRegistros-1)/elementos + 1;
            log.debug("[objetosPaginado] totalRegistros: " + totalRegistros);
            log.debug("[objetosPaginado] totalpaginas: " + totalPaginas);

            int offset = (pagina-1) * elementos;
            int first = (pagina-1)* elementos; //primer registro
            int max = elementos; //ultimo registro

            //log.debug("[select]: " +select);
            q = em.createNativeQuery(select,DatoCadenaNumeros.class);
            q.setFirstResult(first);
            q.setFirstResult(offset);
            q.setMaxResults(max);
            
            log.debug("[objetosPaginado] first: " + first);
            log.debug("[objetosPaginado] max: " + max);

            lista = (List<DatoCadenaNumeros>)q.getResultList();

            log.debug("[objetosPaginado] lista.size: " + lista.size());

            /*for(int i=0;i<lista.size();++i){
                log.debug("objeto: " + lista.get(i).getCadena() + "-" + lista.get(i).getNumero1()+ "-" +lista.get(i).getNumero2() + "-" + lista.get(i).getNumero3() );
            }*/

            setCabecera(new InfoCabeceraXHR());
            getCabecera().setCorrecto(1);
            getCabecera().setActual(getPagina());
            getCabecera().setTotal(totalPaginas);

            int p1=0, p2=0;

            if (getPagina() <= (BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_HUECOS_LADO_PAGINA+1)) {
                p1 = 1;
                p2 = BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_HUECOS_LADO_PAGINA*2 + 1;
            } else if (getPagina() >= (totalPaginas-BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_HUECOS_LADO_PAGINA)) {
                p1 = totalPaginas - (BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_HUECOS_LADO_PAGINA*2);
                p2 = totalPaginas;
            } else {
                p1 = getPagina() - BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_HUECOS_LADO_PAGINA;
                p2 = getPagina() + BaseActionAdmin.LISTADO_ESTADISTICAS_OBJETOS_HUECOS_LADO_PAGINA;
            }
            if (p1 < 1) {
                p1 = 1;
            }
            if (p2 > totalPaginas) {
                p2 = totalPaginas;
            }
            getCabecera().setPrimeraPagina(p1);
            getCabecera().setUltimaPagina(p2);
            getCabecera().setTotalRegistros(totalRegistros);

        }catch(Exception e){
            log.error("Error:" + e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return lista;
    }

    public void activarPaises(){
        /* variables para compartir en acciones JS */
        session.put("pais1",pais1);
        session.put("pais2",pais2);
        session.put("pais3",pais3);
        session.put("pais4",pais4);
        session.put("pais5",pais5);
    }

    public void DesactivarPaises(){
        /* variables para compartir en acciones JS */
        session.put("pais1",null);
        session.put("pais2",null);
        session.put("pais3",null);
        session.put("pais4",null);
        session.put("pais5",null);
    }

    public List<DatoFechaNumero> registradosPorPais(String cod_pais,String orden){
        List<DatoFechaNumero> lista = null;
        try{
            log.debug("[registradosPorPais] fechas: " + fechaInicio +", "+fechaFin);
            if((fechaInicio == null && fechaFin == null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0)){ //si no hay fechas pasados por parametro
                //log.debug("[registradosPorPais] registrados normal");
                //log.debug("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario where pais_id=UPPER('" + cod_pais + "') group by fecha order by fecha "+orden);
                lista = dameFechaNumero("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario where pais_id=UPPER('" + cod_pais + "') group by fecha order by fecha "+orden);
            }else{
                Date fInicio = null;
                Date fFin = null;
                //log.debug("[registradosPorPais] registrados por fechas");
                fInicio = dameFecha(fechaInicio);
                fFin = dameFecha(fechaFin);
                activarFechas(); //para poder ser compartidas por los javascript actions
                log.debug("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "' and pais_id=UPPER('" + cod_pais + "') group by fecha order by fecha "+orden);
                lista = dameFechaNumero("select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.usuario where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "' and pais_id=UPPER('" + cod_pais + "') group by fecha order by fecha "+orden);
            }
        } catch (Exception e) {
            log.error("[registradosPorPais] Error" + e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
        return lista;
    }

    //managers por edad
    public String MporEdad(){

       String retorno=SUCCESS;
       List<DatoCadenaNumero> lista = new ArrayList<DatoCadenaNumero>();
       DatoCadenaNumero aux = null;
       EntityManager em = getBsaadmin().getEmfAdmin().createEntityManager();

       try{
           //compongo la select con una parte comun y partes variables(textos traducidos)
           Query q = em.createNativeQuery("select count(*) as numero from central.usuario");
           int total = ((BigInteger)q.getSingleResult()).intValue();
           String parteComunSQL = "select count(*) from central.usuario u ";
           String[][] variables = {
               {"where (select extract( 'year' from age ( u.f_nacim)))<18", getText("estadisticas.managers_edad.dato_1")},
               {"where (select extract( 'year' from age ( u.f_nacim)))>=18 and (select extract( 'year' from age ( u.f_nacim)))<23", getText("estadisticas.managers_edad.dato_2")},
               {"where (select extract( 'year' from age ( u.f_nacim)))>=23 and (select extract( 'year' from age ( u.f_nacim)))<30", getText("estadisticas.managers_edad.dato_3")},
               {"where (select extract( 'year' from age ( u.f_nacim)))>=30 and (select extract( 'year' from age ( u.f_nacim)))<35", getText("estadisticas.managers_edad.dato_4")},
               {"where (select extract( 'year' from age ( u.f_nacim)))>=35",  getText("estadisticas.managers_edad.dato_5")},
           };

           lista  = new ArrayList<DatoCadenaNumero>();
           
           for(String[] linea : variables) {
               String parteVariableSQL = linea[0];
               String textoArbitrario = linea[1];
               q = em.createNativeQuery(parteComunSQL + " " + parteVariableSQL);

               aux = new DatoCadenaNumero();
               aux.setCadena(textoArbitrario);
               aux.setNumero(((BigInteger)q.getSingleResult()).intValue());
               BigDecimal bd = new BigDecimal((double)100*aux.getNumero()/total);
               bd = bd.setScale(1, RoundingMode.HALF_UP);
               aux.setPorcentaje(bd.doubleValue());
               lista.add(aux);
           }
           for(int i=0;i<lista.size();++i){
            log.debug("lista"+lista.get(i).getCadena()+": "+lista.get(i).getNumero());
           }
           setManagersPorEdad(lista);
        }catch (Exception e) {
            log.error("Error ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    public String tiendaResumenCompras(){
        DesactivarFechas();

        //rescatamos las fechas si se han pasado
        if(fechaResumenInicio!=null && fechaResumenFin!=null
           && fechaResumenInicio.compareTo("")!=0 && fechaResumenFin.compareTo("")!=0){
            fechaInicio = fechaResumenInicio;
            fechaFin = fechaResumenFin;
        }

        String parte_comun = "select date_trunc('day',f_alta) as fecha, count(*) as numero,0 as porcentaje from central.movimiento";
        //compras totales por dia(le paso la parte comun de la select)
        comprasTienda(parte_comun,"");
        comprasTotales = listaAux;
        comprasTotalesInverso = listaAuxInversa;
        //compras en bitoones por dia
        
        comprasTienda(parte_comun,"where valor>0");
        comprasConBitoones = listaAux;
        comprasConBitoonesInverso = listaAuxInversa;
        //compras en duddies por dia
        
        comprasTienda(parte_comun,"where puntos>0");
        comprasConDuddies = listaAux;
        comprasConDuddiesInverso = listaAuxInversa;
        
        //fusionar las tres listas en un array de 4 columnas por fila
        // dia / totales / bitoones / duddies
        ArrayList<DatoFechaNumeros> listaR = new ArrayList<DatoFechaNumeros>();

        log.debug("[tiendaResumenCompras] total:" + totales + ",B$: " + bitoones + ",D$: " + duddies);
        activarInputsTienda();

        if(totales==null && bitoones==null && duddies==null){
            //primera vez que entro en la estadística
            inicializarResumen(listaR,comprasTotalesInverso,1);
            insertarFechaListaResumen(comprasConBitoonesInverso,listaR,2);
            insertarFechaListaResumen(comprasConDuddiesInverso,listaR,3);
        }else{
            //si no se entra por primera vez
            if(totales!=null && totales.compareTo("on")==0){
                log.debug("[resumenDiario] totales entro:" + comprasTotalesInverso.size());
                inicializarResumen(listaR,comprasTotalesInverso,1);
            }

            if(totales!=null && totales.compareTo("on")==0
               &&  bitoones!=null && bitoones.compareTo("on")==0){
                log.debug("[resumenDiario] partidos todos");
                insertarFechaListaResumen(comprasConBitoonesInverso,listaR,2);
            }else{
                if(bitoones!=null && bitoones.compareTo("on")==0){
                    log.debug("[resumenDiario] bitoones inicializo");
                    inicializarResumen(listaR,comprasConBitoonesInverso,2);
                }
            }

            if(totales!=null && bitoones!=null && duddies!=null && totales.compareTo("on")==0
               && bitoones.compareTo("on")==0 && duddies.compareTo("on")==0){
                log.debug("[resumenDiario] usuarios todos");
                insertarFechaListaResumen(comprasConDuddiesInverso,listaR,3);
            }else{
                //combinaciones con totales o bitoones,sino inicializar
                if(totales!=null  && duddies!=null && totales.compareTo("on")==0 && duddies.compareTo("on")==0){
                      log.debug("[resumenDiario] usuarios todos 1");
                      insertarFechaListaResumen(comprasConDuddiesInverso,listaR,3);
                }else{
                    if(bitoones!=null  && duddies!=null && bitoones.compareTo("on")==0 && duddies.compareTo("on")==0){
                        log.debug("[resumenDiario] usuarios todos 2");
                        insertarFechaListaResumen(comprasConDuddiesInverso,listaR,3);
                    }else{
                        if(duddies!=null && duddies.compareTo("on")==0){
                            log.debug("[resumenDiario] usuarios entro");
                            inicializarResumen(listaR,comprasConDuddiesInverso,3);
                        }
                    }
                }
            }
        }

        setListaResumen(listaR);
        //invertir la lista y asignarla
        listaResumenInversa = new ArrayList<DatoFechaNumeros>();
        for(int i=listaResumen.size()-1;i>=0;--i){
            listaResumenInversa.add(listaResumen.get(i));
        }

        return SUCCESS;
    }

    public void comprasTienda(String select,String tipoPago){
        listaAux = null;
        listaAuxInversa = null;
        try{
            log.debug("[comprasTienda] fechas: " + fechaInicio +", "+fechaFin);
            //log.debug("[comprasTienda] select: " + select + " , parte: " + tipoPago);
            if((fechaInicio == null && fechaFin == null && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo==null) ||
               (fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")==0)){ //si no hay fechas pasados por parametro
                log.debug("[comprasTienda] registrados normal");
                listaAux = dameFechaNumero(select + " " + tipoPago + " group by fecha order by fecha desc");
                listaAuxInversa = dameFechaNumero(select + " " + tipoPago + " group by fecha order by fecha asc");
            }else{
                Date fInicio = null;
                Date fFin = null;
                if(fechaInicio == null && fechaFin == null && tipo!=null ||
                   fechaInicio.compareTo("")==0 && fechaFin.compareTo("")==0 && tipo.compareTo("")!=0){
                    //si se ha pasado el tipo de acotamiento de fechas(semana,mes)
                    session.put("tipoFiltro",tipo);
                    if(tipo.compareTo("semana")==0){
                        //Restamos la cantidad en la unidad conveniente,una semana
                        fInicio = dameFechaMenosDias(7);
                    }else{
                        //Restamos la cantidad en la unidad conveniente,un mes
                        fInicio = dameFechaMenosDias(30);
                    }
                    fFin =  new Date();
                    log.debug("[comprasTienda] registrados semana/mes");
                }else{
                    log.debug("[comprasTienda] registrados por fechas");
                    fInicio = dameFecha(fechaInicio);
                    fFin = dameFecha(fechaFin);
                }
                activarFechas(); //para poder ser compartidas por los javascript actions
                //quito el 'where'
                //log.debug("tipoPago: " + tipoPago);
                if(tipoPago.length()>0){
                    tipoPago = "and" + tipoPago.substring(5,tipoPago.length());
                }
                log.debug("tipoPago: " + tipoPago);
                listaAux = dameFechaNumero(select+" where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "' "+tipoPago+" group by fecha order by fecha desc");
                listaAuxInversa = dameFechaNumero(select+" where f_alta >= '" + fInicio + "' and f_alta <= '" + fFin + "' "+tipoPago+" group by fecha order by fecha asc");
            }
        } catch (Exception e) {
            log.error("Error", e);
        } finally {
            try  {/*em.close();*/ } catch (Exception e) { }
        }
    }

     public String managersHabituales(){

        //si la actividad es 0, mostramos toda la lista del ultimo año
        int limite = actividad;
        Date fecha_actual = new Date();
        EntityManager em = null;

        try{
            log.debug("[managersHabituales] actividad: " + actividad);
            em = getBsaadmin().getEmfAdmin().createEntityManager();

            String fecha_desde_string = "";
            String fecha_hasta_string = "";

            String select = "";
            String mes = "";

            Calendar c1 = Calendar.getInstance();
            managersActividad = new ArrayList<DatoCadenaNumero>();

            if(getActividad()==0 || getActividad()==12){
                limite = 12;
            }

            for(int i=1;i<=limite;++i){
                //recibo las fechas, intervalo que crea un mes
                fecha_desde_string = dameFechaDiaUnoMes(fecha_actual,-1);
                fecha_hasta_string = dameFechaDiaUnoMes(fecha_actual,1);

                mes = dameNombreMes(fecha_actual);

                //log.debug("fecha_desde: "+fecha_desde_string +" ,fecha_hasta: "+fecha_hasta_string);

                select = "select '" + mes + "' as cadena,count(distinct(e.usuario_id)) as numero,0 as porcentaje"+
                " from basket.equipo e, basket.partido p where (p.equipo_id1 = e.id or p.equipo_id2 = e.id)  and"+
                " p.f_partido > date_trunc('day',TO_DATE('"+fecha_desde_string+"', 'DD/MM/YYYY')) and"+
                " p.f_partido < date_trunc('day',TO_DATE('"+fecha_hasta_string+"', 'DD/MM/YYYY'))";

                Query q = em.createNativeQuery(select, DatoCadenaNumero.class);
                managersActividad.add((DatoCadenaNumero)q.getSingleResult());
                //voy descendiendo de mes en mes(1 mes)
                c1.add(Calendar.MONTH,-1); //le resto un mes
                fecha_actual = c1.getTime();
            }

            log.debug("[managersHabituales] list.size: " + managersActividad.size());
        } catch (Exception e) {
            log.error("[managersHabituales] Error: " + e.fillInStackTrace());
        } finally {
            try  { em.close(); } catch (Exception e) { }
        }

        //creo la lista inversa
        //invertir la lista y asignarla
        managersActividadInversa = new ArrayList<DatoCadenaNumero>();
        for(int i=managersActividad.size()-1;i>=0;--i){
            managersActividadInversa.add(managersActividad.get(i));
        }

        //activo la actividad para la action del .js
        session.put("est_finicio",actividad);

        return SUCCESS;
    }

    private String dameFechaDiaUnoMes(Date fecha_actual,int operacion){
        /*Me devuelve el dia uno del mes de la fecha pasada por parametro 
         si operacion=-1 o la del siguiente mes si operacion=1*/

        Date fecha=null;
        SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");

        String fecha_string;

        String fecha_formato = formato.format(fecha_actual);
        String[] partes = fecha_formato.split("/");
        int mes = Integer.parseInt(partes[1]);

        if(operacion!=1){
            --mes;
        }

        try {
            fecha = formato.parse("32/"+mes+"/"+partes[2]); //dia 1 del mes actual
        } catch (Exception ex) { log.debug("[baneo] Error al parsear la fecha.",ex); }

        fecha_string = formato.format(fecha);

        return fecha_string;
    }

    private String dameNombreMes(Date fecha){
        /* Me devuelve el nombre del mes de una fecha dada*/

        SimpleDateFormat formato = new SimpleDateFormat("MMMM yyyy");

        String fecha_string = formato.format(fecha);

        log.debug("mes: " + fecha_string);

        return fecha_string;
    }


    public void activarInputsTienda(){
        /* variables para compartir en acciones JS */
        session.put("totales", totales);
        session.put("bitoones",bitoones);
        session.put("duddies",duddies);
    }


    public void DesactivarInputsTienda(){
        /* variables para compartir en acciones JS */
        session.put("totales", null);
        session.put("bitoones",null);
        session.put("duddies",null);
    }

    public int getUsuariosActivosTotales() {
        return usuariosActivosTotales;
    }

    public void setUsuariosActivosTotales(int usuariosActivosTotales) {
        this.usuariosActivosTotales = usuariosActivosTotales;
    }

    public int getEquiposCreadosTotales() {
        return equiposCreadosTotales;
    }

    public void setEquiposCreadosTotales(int equiposCreadosTotales) {
        this.equiposCreadosTotales = equiposCreadosTotales;
    }

    public List<DatoFechaNumero> getUsuariosRegistrados() {
        return usuariosRegistrados;
    }

    public void setUsuariosRegistrados(List<DatoFechaNumero> usuariosRegistrados) {
        this.usuariosRegistrados = usuariosRegistrados;
    }

    public List<DatoFechaNumero> getEquiposPorDia() {
        return equiposPorDia;
    }

    public void setEquiposPorDia(List<DatoFechaNumero> equiposPorDia) {
        this.equiposPorDia = equiposPorDia;
    }

    public List<DatoFechaNumero> getPartidosPorDia() {
        return partidosPorDia;
    }

    public void setPartidosPorDia(List<DatoFechaNumero> partidosPorDia) {
        this.partidosPorDia = partidosPorDia;
    }

    public int getUsuariosNoActivados() {
        return usuariosNoActivados;
    }

    public void setUsuariosNoActivados(int usuariosNoActivados) {
        this.usuariosNoActivados = usuariosNoActivados;
    }

    public int getUsuariosConEquipo() {
        return usuariosConEquipo;
    }

    public void setUsuariosConEquipo(int usuariosConEquipo) {
        this.usuariosConEquipo = usuariosConEquipo;
    }

    public List<DatoCadenaNumero> getEquiposPorPartidosJugados() {
        return equiposPorPartidosJugados;
    }

    public void setEquiposPorPartidosJugados(List<DatoCadenaNumero> equiposPorPartidosJugados) {
        this.equiposPorPartidosJugados = equiposPorPartidosJugados;
    }

    public List<DatoCadenaNumero> getManagersPorPartidosJugados() {
        return managersPorPartidosJugados;
    }

    public void setManagersPorPartidosJugados(List<DatoCadenaNumero> managersPorPartidosJugados) {
        this.managersPorPartidosJugados = managersPorPartidosJugados;
    }

    public List<DatoCadenaNumero> getManagersPorGenero() {
        return managersPorGenero;
    }

    public void setManagersPorGenero(List<DatoCadenaNumero> managersPorGenero) {
        this.managersPorGenero = managersPorGenero;
    }

    public List<DatoCadenaNumero> getManagersPorPais() {
        return managersPorPais;
    }

    public void setManagersPorPais(List<DatoCadenaNumero> managersPorPais) {
        this.managersPorPais = managersPorPais;
    }

    public List<DatoCadenaNumero> getManagersXdiasSinJugar() {
        return managersXdiasSinJugar;
    }

    public void setManagersXdiasSinJugar(List<DatoCadenaNumero> managersXdiasSinJugar) {
        this.managersXdiasSinJugar = managersXdiasSinJugar;
    }

    public String getNick() {
        return nick;
    }

    public void setNick(String nick) {
        this.nick = nick;
    }

    public Usuario getManager() {
        return manager;
    }

    public void setManager(Usuario manager) {
        this.manager = manager;
    }

    public String getFechas() {
        return fechas;
    }

    public void setFechas(String fechas) {
        this.fechas = fechas;
    }

    public String getFechaInicio() {
        return fechaInicio;
    }

    public void setFechaInicio(String fechaInicio) {
        this.fechaInicio = fechaInicio;
    }

    public String getFechaFin() {
        return fechaFin;
    }

    public void setFechaFin(String fechaFin) {
        this.fechaFin = fechaFin;
    }

    public List<DatoCadenaNumero> getEquiposPorNivel() {
        return equiposPorNivel;
    }

    public void setEquiposPorNivel(List<DatoCadenaNumero> equiposPorNivel) {
        this.equiposPorNivel = equiposPorNivel;
    }

    public List<DatoCadenaNumero> getNivelSemana() {
        return nivelSemana;
    }

    public void setNivelSemana(List<DatoCadenaNumero> nivelSemana) {
        this.nivelSemana = nivelSemana;
    }

    public List<PartidoEnJuego> getPartidoJuego() {
        return partidoJuego;
    }

    public void setPartidoJuego(List<PartidoEnJuego> partidoJuego) {
        this.partidoJuego = partidoJuego;
    }

    public List<PartidoParaComentar> getPartidoComentar() {
        return partidoComentar;
    }

    public void setPartidoComentar(List<PartidoParaComentar> partidoComentar) {
        this.partidoComentar = partidoComentar;
    }

    public List<DatoFechaNumero> getUsuariosRegistradosInverso() {
        return usuariosRegistradosInverso;
    }

    public void setUsuariosRegistradosInverso(List<DatoFechaNumero> usuariosRegistradosInverso) {
        this.usuariosRegistradosInverso = usuariosRegistradosInverso;
    }

    public List<DatoFechaNumero> getPartidosPorDiaInverso() {
        return partidosPorDiaInverso;
    }

    public void setPartidosPorDiaInverso(List<DatoFechaNumero> partidosPorDiaInverso) {
        this.partidosPorDiaInverso = partidosPorDiaInverso;
    }

    public List<DatoFechaNumero> getEquiposPorDiaInverso() {
        return equiposPorDiaInverso;
    }

    public void setEquiposPorDiaInverso(List<DatoFechaNumero> equiposPorDiaInverso) {
        this.equiposPorDiaInverso = equiposPorDiaInverso;
    }

    public String getTipo() {
        return tipo;
    }

    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    public List<DatoFechaNumeros> getListaResumen() {
        return listaResumen;
    }

    public void setListaResumen(List<DatoFechaNumeros> listaResumen) {
        this.listaResumen = listaResumen;
    }

    public String getFechaResumenInicio() {
        return fechaResumenInicio;
    }

    public void setFechaResumenInicio(String fechaResumenInicio) {
        this.fechaResumenInicio = fechaResumenInicio;
    }

    public String getFechaResumenFin() {
        return fechaResumenFin;
    }

    public void setFechaResumenFin(String fechaResumenFin) {
        this.fechaResumenFin = fechaResumenFin;
    }

    public String getEquipos() {
        return equipos;
    }

    public void setEquipos(String equipos) {
        this.equipos = equipos;
    }

    public String getPartidos() {
        return partidos;
    }

    public void setPartidos(String partidos) {
        this.partidos = partidos;
    }

    public String getUsuarios() {
        return usuarios;
    }

    public void setUsuarios(String usuarios) {
        this.usuarios = usuarios;
    }

    public List<DatoFechaNumeros> getListaResumenInversa() {
        return listaResumenInversa;
    }

    public void setListaResumenInversa(List<DatoFechaNumeros> listaResumenInversa) {
        this.listaResumenInversa = listaResumenInversa;
    }

    public List<List<DatoFechaNumero>> getMatriz_managersPorPais() {
        return matriz_managersPorPais;
    }

    public void setMatriz_managersPorPais(List<List<DatoFechaNumero>> matriz_managersPorPais) {
        this.matriz_managersPorPais = matriz_managersPorPais;
    }

    public String getPais1() {
        return pais1;
    }

    public void setPais1(String pais1) {
        this.pais1 = pais1;
    }

    public String getPais2() {
        return pais2;
    }

    public void setPais2(String pais2) {
        this.pais2 = pais2;
    }

    public String getPais3() {
        return pais3;
    }

    public void setPais3(String pais3) {
        this.pais3 = pais3;
    }

    public String getPais4() {
        return pais4;
    }

    public void setPais4(String pais4) {
        this.pais4 = pais4;
    }

    public String getPais5() {
        return pais5;
    }

    public void setPais5(String pais5) {
        this.pais5 = pais5;
    }

    public List<List<String>> getListaPaises() {
        return listaPaises;
    }

    public void setListaPaises(List<List<String>> listaPaises) {
        this.listaPaises = listaPaises;
    }

    public List<DatoCadenaNumero> getManagersPorEdad() {
        return managersPorEdad;
    }

    public void setManagersPorEdad(List<DatoCadenaNumero> managersPorEdad) {
        this.managersPorEdad = managersPorEdad;
    }

    public String getNombre_pais1() {
        return nombre_pais1;
    }

    public void setNombre_pais1(String nombre_pais1) {
        this.nombre_pais1 = nombre_pais1;
    }

    public String getNombre_pais2() {
        return nombre_pais2;
    }

    public void setNombre_pais2(String nombre_pais2) {
        this.nombre_pais2 = nombre_pais2;
    }

    public String getNombre_pais3() {
        return nombre_pais3;
    }

    public void setNombre_pais3(String nombre_pais3) {
        this.nombre_pais3 = nombre_pais3;
    }

    public String getNombre_pais4() {
        return nombre_pais4;
    }

    public void setNombre_pais4(String nombre_pais4) {
        this.nombre_pais4 = nombre_pais4;
    }

    public String getNombre_pais5() {
        return nombre_pais5;
    }

    public void setNombre_pais5(String nombre_pais5) {
        this.nombre_pais5 = nombre_pais5;
    }

    public List<DatoCadenaNumeros> getListaRopa() {
        return listaRopa;
    }

    public void setListaRopa(List<DatoCadenaNumeros> listaRopa) {
        this.listaRopa = listaRopa;
    }

    public List<DatoCadenaNumeros> getListaSobres() {
        return listaSobres;
    }

    public void setListaSobres(List<DatoCadenaNumeros> listaSobres) {
        this.listaSobres = listaSobres;
    }

    public List<DatoCadenaNumeros> getListaJugadores() {
        return listaJugadores;
    }

    public void setListaJugadores(List<DatoCadenaNumeros> listaJugadores) {
        this.listaJugadores = listaJugadores;
    }

    public List<DatoCadenaNumeros> getListaCartas() {
        return listaCartas;
    }

    public void setListaCartas(List<DatoCadenaNumeros> listaCartas) {
        this.listaCartas = listaCartas;
    }

    public InfoCabeceraXHR getCabecera() {
        return cabecera;
    }

    public void setCabecera(InfoCabeceraXHR cabecera) {
        this.cabecera = cabecera;
    }

    public int getPagina() {
        return pagina;
    }

    public void setPagina(int pagina) {
        this.pagina = pagina;
    }

    public int getCuantos() {
        return cuantos;
    }

    public void setCuantos(int cuantos) {
        this.cuantos = cuantos;
    }

    public String getFamilia() {
        return familia;
    }

    public void setFamilia(String familia) {
        this.familia = familia;
    }

    public List<DatoCadenaNumeros> getDatos() {
        return datos;
    }

    public void setDatos(List<DatoCadenaNumeros> datos) {
        this.datos = datos;
    }

    public InfoCabeceraXHR getCabecera_jugadores() {
        return cabecera_jugadores;
    }

    public void setCabecera_jugadores(InfoCabeceraXHR cabecera_jugadores) {
        this.cabecera_jugadores = cabecera_jugadores;
    }

    public InfoCabeceraXHR getCabecera_ropa() {
        return cabecera_ropa;
    }

    public void setCabecera_ropa(InfoCabeceraXHR cabecera_ropa) {
        this.cabecera_ropa = cabecera_ropa;
    }

    public InfoCabeceraXHR getCabecera_cartas() {
        return cabecera_cartas;
    }

    public void setCabecera_cartas(InfoCabeceraXHR cabecera_cartas) {
        this.cabecera_cartas = cabecera_cartas;
    }

    public List<Pais> getDesplegablePaises() {
        return desplegablePaises;
    }

    public void setDesplegablePaises(List<Pais> desplegablePaises) {
        this.desplegablePaises = desplegablePaises;
    }

    public String getTotales() {
        return totales;
    }

    public void setTotales(String totales) {
        this.totales = totales;
    }

    public String getBitoones() {
        return bitoones;
    }

    public void setBitoones(String bitoones) {
        this.bitoones = bitoones;
    }

    public String getDuddies() {
        return duddies;
    }

    public void setDuddies(String duddies) {
        this.duddies = duddies;
    }

    public List<DatoFechaNumero> getComprasTotales() {
        return comprasTotales;
    }

    public void setComprasTotales(List<DatoFechaNumero> comprasTotales) {
        this.comprasTotales = comprasTotales;
    }

    public List<DatoFechaNumero> getComprasTotalesInverso() {
        return comprasTotalesInverso;
    }

    public void setComprasTotalesInverso(List<DatoFechaNumero> comprasTotalesInverso) {
        this.comprasTotalesInverso = comprasTotalesInverso;
    }

    public List<DatoFechaNumero> getComprasConBitoones() {
        return comprasConBitoones;
    }

    public void setComprasConBitoones(List<DatoFechaNumero> comprasConBitoones) {
        this.comprasConBitoones = comprasConBitoones;
    }

    public List<DatoFechaNumero> getComprasConBitoonesInverso() {
        return comprasConBitoonesInverso;
    }

    public void setComprasConBitoonesInverso(List<DatoFechaNumero> comprasConBitoonesInverso) {
        this.comprasConBitoonesInverso = comprasConBitoonesInverso;
    }

    public List<DatoFechaNumero> getComprasConDuddies() {
        return comprasConDuddies;
    }

    public void setComprasConDuddies(List<DatoFechaNumero> comprasConDuddies) {
        this.comprasConDuddies = comprasConDuddies;
    }

    public List<DatoFechaNumero> getComprasConDuddiesInverso() {
        return comprasConDuddiesInverso;
    }

    public void setComprasConDuddiesInverso(List<DatoFechaNumero> comprasConDuddiesinverso) {
        this.comprasConDuddiesInverso = comprasConDuddiesinverso;
    }

    public List<DatoFechaNumero> getAux() {
        return listaAux;
    }

    public void setAux(List<DatoFechaNumero> aux) {
        this.listaAux = aux;
    }

    public List<DatoFechaNumero> getListaAuxInversa() {
        return listaAuxInversa;
    }

    public void setListaAuxInversa(List<DatoFechaNumero> listaAuxInversa) {
        this.listaAuxInversa = listaAuxInversa;
    }

    public int dameFechaActualMes() {
        Date fecha_actual = new Date();
        SimpleDateFormat simpleDateformat=new SimpleDateFormat("MM");
        return Integer.parseInt(simpleDateformat.format(fecha_actual));
    }

    public int getActividad() {
        return actividad;
    }

    public void setActividad(int actividad) {
        this.actividad = actividad;
    }

    public List<DatoCadenaNumero> getManagersActividad() {
        return managersActividad;
    }

    public void setManagersActividad(List<DatoCadenaNumero> managersActividad) {
        this.managersActividad = managersActividad;
    }

    public List<DatoCadenaNumero> getManagersActividadInversa() {
        return managersActividadInversa;
    }

    public void setManagersActividadInversa(List<DatoCadenaNumero> managersActividadInversa) {
        this.managersActividadInversa = managersActividadInversa;
    }

    public BaseActionAdmin getBsaadmin() {
        return bsaadmin;
    }

    public void setBsaadmin(BaseActionAdmin bsaadmin) {
        this.bsaadmin = bsaadmin;
    }
}